/*
 * syntax.cpp
 *
 *   Created on: 2011-10-22
 *       Author: 左白
 *  Description: 语法分析
 */

#include "parse.h"
#include <cstdarg>

namespace zach
{
// 非终结符枚举
namespace nonTerminalType
{
enum NonTerminalType
{
	S, TermMul, OpMul, TermAdd, OpAdd, TermComp, OpComp, TokenList, ENUMMAX
};
}
typedef nonTerminalType::NonTerminalType NonTerminalType;

// 非终结符
struct NonTerminal
{
};

// 语法词
struct SyntaxWord
{
	SyntaxWord( LexType type ) :
			isTerminal( true ), terminalType( type )
	{
	}

	SyntaxWord( NonTerminalType type ) :
			isTerminal( false ), nonTerminalType( type )
	{
	}

	bool isTerminal; // 是否是终结符
	union
	{
		LexType terminalType; // 终结符类型
		NonTerminalType nonTerminalType; // 非终结符类型
	};
};
inline bool operator==( const SyntaxWord& lhs, const SyntaxWord& rhs )
{
	return lhs.isTerminal == rhs.isTerminal ?
			lhs.isTerminal == true ? lhs.terminalType == rhs.terminalType : lhs.nonTerminalType == rhs.nonTerminalType
			: false;
}
SyntaxWord end = SyntaxWord( lexType::ENUMEND ); // 用来中止一个文法

// 文法
struct Grammar
{
	Grammar( NonTerminalType type, ... )
	{
		va_list ap;
		va_start( ap, type );

		nonTerminalType = type;

		while ( true ) {
			SyntaxWord sw = va_arg( ap, SyntaxWord );
			if ( sw == end ) {
				break;
			}
			else {
				permutation.push_back( sw );
			}
		}
	}

	NonTerminalType nonTerminalType;
	vector<SyntaxWord> permutation;
};

// 终结符
#define T( tType )\
	SyntaxWord( lexType::tType )

// 非终结符
#define NT( ntType )\
	SyntaxWord( nonTerminalType::ntType )

// 文法
#define G( ntType, ... )\
	Grammar( nonTerminalType::ntType, __VA_ARGS__, end )

Grammar grammars[] = {
#if (1) /* 起始状态 */
		G( S, NT( TermComp ) ),
#endif /* 起始状态 */
#if (1) /* 乘法相关 */
		G( OpMul, T( Mul ) ), G( OpMul, T( Div ) ), G( OpMul, T( Mod ) ), // 符号
		G( TermMul, T( TOKEN ) ), G( TermMul, NT( TermMul ), NT( OpMul ), T( TOKEN ) ),
#endif /* 乘法相关 */
#if (1) /* 加法相关 */
		G( OpAdd, T( Add ) ), G( OpAdd, T( Sub ) ), // 符号
		G( TermAdd, NT( TermMul ) ), G( TermAdd, NT( TermAdd ), NT( OpAdd ), NT( TermMul ) ),
#endif /* 加法相关 */
#if (1) /* 比较相关 */
		G( OpComp, T( Less ) ), G( OpComp, T( Great ) ), G( OpComp, T( LessEqual ) ), G( OpComp, T( GreatEqual ) ), // 符号
		G( TermComp, NT( TermAdd ) ), G( TermComp, NT( TermComp ), NT( OpComp ), NT( TermAdd ) ),
#endif /* 比较相关 */
#if (1) /* 枚举 */
		G( TokenList, T( TOKEN ) ), G( TokenList, NT( TokenList ), T( Comma ), T( TOKEN ) )
#endif /* 枚举 */
		};

#if (1) /* 语法机 */
template<Grammar* grammars, int grammarsLength>
class GrammarMachine
{

};
#endif /* 语法机 */
}
